"""
序列四种类型
列表[]，元组()，字典（键值对），集合{}
切片：sname[start:end:step]step步长。左闭右开，适用于列表和元组
例：
list1=[i for i in range(11)]
list2=list1[0:10:2] #这个切片函数必须用中括号
print(list2)

序列加法（集合不能加）   hero3=hero2+hero1
序列乘法（集合不行）   hero3=hero3*3
检查是否是序列成员   "鲁班"not in hero
序列长度    len(hero)
max和min函数：看ascⅡ码  max(hero)

列表：
赋值   hero=[...]
加入元素（类型不一定相同）  hero.append(100)
求和，最大，最小   sum(hero)
转化为列表   list函数  list1=list("哈哈哈")
删除  del函数 del hero[1]
倒过来用负数    list[-1]#最后一个元素
输出列表 (遍历列表）    for item in listname:
for index,item in enumerate(list1):
    print(index,item)
添加   list2.append("...")
插入  insert()
扩展,追加  list1.extend(list2)
修改    list1[1]='3'
删除（次数）   if list1.count("444")>0可以用来查询文章中有多少个特定字
                list1.remove("444")
统计元素出现位置    list4.index("民")
list1=list(random.randint(1,1000) for item in range(100) )
列表排序 listname.sort()升序
        sorted(list2)没有改变本身list2的元素

元组：
元组不能修改
tuple1=(1,3,5)
有逗号是元组，没都好是啥就是啥，也可以元素转化
元组访问速度比列表快，列表不能作为字典的键，但是元组可以


函数：
参数的传递、实参、形参
可变参数：*任意多个(传列表等进去）
def sun(a,b):
    result =a+b
    return result

字典：
无序的可变序列，键值对
dictionary={"key1":"value1","key2":"value2"...}
dictionary=dict{zip(list1,list2)}
divtionary=dict(key1=calue1...)
dict1={tuple1:list1}
合并字典：dict1.update(dict2)
访问字典：
print(dict1["20243402"])
print(dictionary)
遍历字典：
dictionary.items()遍历键值对
for item in dict1.items():
    print(item)
for item,value in dict1.items()
    print(item,value)
添加，修改：
dictionary[key]=value

randomnumber={i:random.randint(1,31) for i in range(1,11)}

集合：
直接使用{}创建，使用set()
添加：.add()
可以进行&|+-

列表 可变 可重复 有序[]
元组 不可变 可重复 有序()
字典 可变 可重复 无序{key:value}
集合 可变 不可重复 无序{}



字符串
拼接：+，重复字符串：*
“1”*5-->五个1
截断：st1[2]  st1[5:](截断后面所有)  st1[:5]  st1[2:5]
分割字符串：str.split(' ',1)
统计次数：string1.count("!")
是否在string.find(); "你" in string1
大小写：lower()  upper()
去掉首位特殊字符：回车空格等strip() listrip() rstrip()
1.使用%格式化字符串：pi = 3.1415926
formatted_pi = "The value of pi is %.2f %s" % (pi,str1)
%-左对齐m宽度
2.format()
info = "My name is {:+.2f}, and I am {} years old.".format(name, age)
.format(**site)#字典
有好多好多啊啊啊啊啊



正则表达式：
描述了一种字符串匹配的模式，将匹配的子串提取出来
runoo+b #+代表+前面的字母至少出现一次
*代表可以0.1.多次
？代表前面的字符最多只能出现一次
普通字符：字母，符号等
特殊字符（元字符）：
.可匹配除换行字符意外的任意字符
\W匹配除字母数字下划线或汉字以外的字符
\w匹配字母，数字，下划线，汉字
\d匹配数字
^匹配开始
$匹配结束
*代表任意多个
例：^\d{8}$
r就不用写开始和结尾
{n,m}#至少n次，至多m次employe{0,2}
用[]表示没有在上面定义的
排除字符用^，选择字符用|
import re   
re.match(pattern,string,[flag])#flag可以是A（只匹配askⅡ）I（忽略大小写）X等 通常不写flag
查找re.search(  )  re.findall(pattern,string ,re.I)
替换re.sub(pattern,"hello",string,count,re.I)

封装+继承+多态
类等于属性（姓名，爱好）（变量）加方法（动作：打篮球踢足球）（函数）string.count("人民")#类的方法
类：具有相同属性和行为的一些对象的统称或集合
定义：
class ClassName:
"""
...
"""
    类体
举例：
class Animal:
    name="mingzi"
    
    def __init__(self): #方法重写
        print("这是动物“)
    
cat=Animal()
print(cat)
使用：cat.name

单下划线:外部访问会被提示、双下划线:只允许类本身和子类进行访问、首尾双下划线：系统规定的


class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类的构造函数
        self.breed = breed

    def speak(self):
        print(f"{self.name} barks.")  # 重写父类的方法

# 使用
animal = Animal("Generic Animal")
animal.speak()  # 输出: Generic Animal makes a sound.

dog = Dog("Buddy", "Golden Retriever")
dog.speak()     # 输出: Buddy barks.

socket编程技术：
socket=IP+port
应用程序通常通过socket在不同设备发送接收请求（实现通讯），在一台计算机的进程之间可以实现
低级别（操作系统）os，高级别（网络服务模块）server
socket(family,type[,protocol])
socket类型:
1.socket.AF_UNIX
socket.AF_INET
socket.AF_INET6

2.socket.SOCK_STREAM(gcd协议）
socket.SOCK_DGRAM

初始化
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

socket函数：
s.bind(address) #必须是元组（绑定）
s.listen(backlog)#开始监听，backlog最大数量
s.accept()#接受并返回(conn,address)新的套接对象，客户端地址
s.connect(address)

公共socket函数：
s.recv(bufsize[,flag]) #接收数据，返回字符串
s.send(string[,falg])#发送到连接的套接字，有返回值
s.close()#关闭套接字


"""
import random
list1=list(random.randint(1,1000) for item in range(100) )
#for item in list1:
    #print(item)
list2=list(range(51,100))
list1.extend(list2)
print(list1)
c